home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / util / libs / jpeglibrary50.lha / jpeglibrary / examples / save / save_file.c next >
C/C++ Source or Header  |  1999-01-30  |  5KB  |  178 lines
  1. /* This example use of jpeg.library loads the jpeg file specified
  2.         on the command line and saves a version halved in size to
  3.         'RAM:halved.jpg'. It uses RGB triplet buffer tags to store/supply the
  4.         image data to/from jpeg.library. This example uses AmigaDOS file
  5.         pointers for the source/destination image streams. It also demonstrates
  6.         the use of a progress indicator callback hook.
  7.  
  8.         Does NOT support greyscale jpegs (not implemented in this application
  9.         but jpeg.library supports them).
  10. */
  11.  
  12. #include <stdio.h>
  13.  
  14. #include <dos/dos.h>
  15. #include <exec/memory.h>
  16. #include <exec/types.h>
  17.  
  18. #include <clib/dos_protos.h>
  19. #include <clib/exec_protos.h>
  20.  
  21. #include <pragmas/dos_pragmas.h>
  22. #include <pragmas/exec_pragmas.h>
  23.  
  24. #include "jpeg/jpeg.h"
  25. #include "jpeg/jpeg_protos.h"
  26. #include "jpeg/jpeg_pragmas.h"
  27.  
  28. /* Function prototypes */
  29. __saveds __asm ULONG progressFunc( register __d0 ULONG curr, register __d1 ULONG lines, register __a0 void *userdata );
  30.  
  31. extern struct Library *DOSBase;
  32. struct Library *JpegBase;
  33.  
  34. void main( int argc, char **argv )
  35. {
  36.     JpegBase = OpenLibrary( "jpeg.library", 2 );
  37.     if ( JpegBase != NULL )
  38.     {
  39.         ULONG err;
  40.         struct JPEGDecHandle *jph;
  41.         struct JPEGComHandle *jpc;
  42.         UBYTE *jstream, *cstream;
  43.         ULONG jstreamsize, cstreamsize;
  44.         UBYTE *buffer;
  45.         ULONG x, y;
  46.         BPTR fp, lock, out;
  47.         struct FileInfoBlock *fib;
  48.         UBYTE colourspace;
  49.  
  50.         fib = AllocDosObject( DOS_FIB, TAG_DONE );
  51.         if ( fib != NULL )
  52.         {
  53.             lock = Lock( argv[1], ACCESS_READ );
  54.             if ( lock != NULL )
  55.             {
  56.                 if ( Examine( lock, fib ) )
  57.                 {
  58.                     jstreamsize = fib->fib_Size;
  59.  
  60.                     jstream = AllocVec( jstreamsize, MEMF_PUBLIC | MEMF_CLEAR );
  61.                     if ( jstream != NULL )
  62.                     {
  63.                         fp = OpenFromLock( lock );
  64.                         if ( fp != NULL )
  65.                         {
  66.                             /* Spool file into memory */
  67.                             Read( fp, jstream, jstreamsize );
  68.  
  69.                             Close( fp );
  70.  
  71.                             err = AllocJPEGDecompress( &jph,
  72.                                 JPG_SrcMemStream, jstream,
  73.                                 JPG_SrcMemStreamSize, jstreamsize,
  74.                                 TAG_DONE );
  75.                             if ( !err )
  76.                             {
  77.                                 err = GetJPEGInfo( jph,
  78.                                     JPG_Width, &x, JPG_Height, &y,
  79.                                     JPG_ColourSpace, &colourspace,
  80.                                     JPG_ScaleNum, 1, JPG_ScaleDenom, 2,
  81.                                     TAG_DONE );
  82.                                 if ( !err )
  83.                                 {
  84.                                     printf( "colourspace=%d\n", colourspace );
  85.                                     printf( "scaled by half to %dx %d\n", x, y );
  86.  
  87.                                     buffer = AllocRGBFromJPEG( jph,
  88.                                         JPG_ScaleNum, 1, JPG_ScaleDenom, 2,
  89.                                         TAG_DONE );
  90.                                     if ( buffer != NULL )
  91.                                     {
  92.                                         err = DecompressJPEG( jph,
  93.                                             JPG_DestRGBBuffer, buffer,
  94.                                             JPG_ProgressHook, progressFunc,
  95.                                             JPG_ScaleNum, 1, JPG_ScaleDenom, 2,
  96.                                             TAG_DONE );
  97.                                         if ( !err )
  98.                                         {
  99.                                             err = AllocJPEGCompress( &jpc,
  100.                                                 JPG_DestMemStream, &cstream,
  101.                                                 JPG_DestMemStreamSize, &cstreamsize,
  102.                                                 TAG_DONE );
  103.                                             if ( !err )
  104.                                             {
  105.                                                 err = CompressJPEG( jpc,
  106.                                                     JPG_SrcRGBBuffer, buffer,
  107.                                                     JPG_Width, x, JPG_Height, y,
  108.                                                     JPG_Progressive, FALSE,
  109.                                                     TAG_DONE );
  110.                                                 if ( !err )
  111.                                                 {
  112.                                                     out = Open( "ram:halved.jpg", MODE_NEWFILE );
  113.                                                     if ( out != NULL )
  114.                                                     {
  115.                                                         printf( "jpeg saved ok\n" );
  116.  
  117.                                                         Write( out, cstream, cstreamsize );
  118.  
  119.                                                         Close( out );
  120.                                                     }
  121.                                                 }
  122.                                                 else printf( "comrpess jpeg error:%d\n", err );
  123.  
  124.                                                 if ( cstream != NULL ) FreeVec( cstream );
  125.  
  126.                                                 FreeJPEGCompress( jpc );
  127.                                             }
  128.                                             else printf( "alloc jpeg error:%d\n", err );
  129.                                         }
  130.                                         else printf( "descompress jpeg error:%d\n", err );
  131.  
  132.                                         FreeJPEGRGBBuffer( buffer );
  133.                                     }
  134.                                     else printf( "cant allocate rgb buffer\n" );
  135.                                 }
  136.                                 else printf( "get jpeg info error:%d\n", err );
  137.  
  138.                                 FreeJPEGDecompress( jph );
  139.                             }
  140.                             else printf( "alloc jpeg error:%d\n", err );
  141.                         }
  142.                         else printf( "cant open file from lock\n" );
  143.  
  144.                         FreeVec( jstream );
  145.                     }
  146.                     else printf( "cant allocate jstream buffer\n" );
  147.  
  148.                 }
  149.                 else printf( "cant examine file\n" );
  150.  
  151.                 UnLock( lock );
  152.             }
  153.             else printf( "cant open file\n" );
  154.  
  155.             FreeDosObject( DOS_FIB, fib );
  156.         }
  157.         else printf( "cant allocate fib\n" );
  158.     }
  159.  
  160.     if ( JpegBase != NULL ) CloseLibrary( JpegBase );
  161. }
  162.  
  163. __saveds __asm ULONG progressFunc( register __d0 ULONG curr, register __d1 ULONG lines, register __a0 void *userdata )
  164. {
  165.     static int prevpercent = 0;
  166.  
  167.     int percent = ( curr * 100 ) / lines;
  168.  
  169.     if ( prevpercent != percent )
  170.     {
  171.         if ( percent % 10 == 0 ) printf( "%d%%\n", percent );
  172.     }
  173.  
  174.     prevpercent = percent;
  175.  
  176.     return NULL;
  177. }
  178.